home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 2 / Apprentice-Release2.iso / Tools / Languages / MacGambit 2.0 / sources2 / Interp⁄Comp (.scm) / target-m68000-3.scm < prev    next >
Encoding:
Text File  |  1992-09-08  |  27.2 KB  |  244 lines  |  [TEXT/gamI]
  1. ;==============================================================================
  2.  
  3. ; file: "target-m68000-3.scm"
  4.  
  5. ;------------------------------------------------------------------------------
  6. ;
  7. ; Primitive procedure database (for M68000):
  8.  
  9. ; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  10.  
  11. (define prim-procs '
  12. (
  13. ;                                    side-effects?  strictness  result
  14. ;                                                \  pattern     type
  15. ; name                            call pattern     \   \          |
  16. ;  /                                    \            \   \        |
  17. ("not"                                   (1)          #f 0        BOOLEAN)
  18. ("boolean?"                              (1)          #f 0        BOOLEAN)
  19. ("eqv?"                                  (2)          #f 0        BOOLEAN)
  20. ("eq?"                                   (2)          #f 0        BOOLEAN)
  21. ("equal?"                                (2)          #f 0        BOOLEAN)
  22. ("pair?"                                 (1)          #f 0        BOOLEAN)
  23. ("cons"                                  (2)          #f ()       PAIR   )
  24. ("car"                                   (1)          #f 0        (#f)   )
  25. ("cdr"                                   (1)          #f 0        (#f)   )
  26. ("set-car!"                              (2)          #t (1)      PAIR   )
  27. ("set-cdr!"                              (2)          #t (1)      PAIR   )
  28. ("caar"                                  (1)          #f 0        (#f)   )
  29. ("cadr"                                  (1)          #f 0        (#f)   )
  30. ("cdar"                                  (1)          #f 0        (#f)   )
  31. ("cddr"                                  (1)          #f 0        (#f)   )
  32. ("caaar"                                 (1)          #f 0        (#f)   )
  33. ("caadr"                                 (1)          #f 0        (#f)   )
  34. ("cadar"                                 (1)          #f 0        (#f)   )
  35. ("caddr"                                 (1)          #f 0        (#f)   )
  36. ("cdaar"                                 (1)          #f 0        (#f)   )
  37. ("cdadr"                                 (1)          #f 0        (#f)   )
  38. ("cddar"                                 (1)          #f 0        (#f)   )
  39. ("cdddr"                                 (1)          #f 0        (#f)   )
  40. ("caaaar"                                (1)          #f 0        (#f)   )
  41. ("caaadr"                                (1)          #f 0        (#f)   )
  42. ("caadar"                                (1)          #f 0        (#f)   )
  43. ("caaddr"                                (1)          #f 0        (#f)   )
  44. ("cadaar"                                (1)          #f 0        (#f)   )
  45. ("cadadr"                                (1)          #f 0        (#f)   )
  46. ("caddar"                                (1)          #f 0        (#f)   )
  47. ("cadddr"                                (1)          #f 0        (#f)   )
  48. ("cdaaar"                                (1)          #f 0        (#f)   )
  49. ("cdaadr"                                (1)          #f 0        (#f)   )
  50. ("cdadar"                                (1)          #f 0        (#f)   )
  51. ("cdaddr"                                (1)          #f 0        (#f)   )
  52. ("cddaar"                                (1)          #f 0        (#f)   )
  53. ("cddadr"                                (1)          #f 0        (#f)   )
  54. ("cdddar"                                (1)          #f 0        (#f)   )
  55. ("cddddr"                                (1)          #f 0        (#f)   )
  56. ("null?"                                 (1)          #f 0        BOOLEAN)
  57. ("list?"                                 (1)          #f 0        BOOLEAN)
  58. ("list"                                  0            #f ()       LIST   )
  59. ("length"                                (1)          #f 0        INTEGER)
  60. ("append"                                0            #f 0        LIST   )
  61. ("reverse"                               (1)          #f 0        LIST   )
  62. ("list-ref"                              (2)          #f 0        (#f)   )
  63. ("memq"                                  (2)          #f 0        LIST   )
  64. ("memv"                                  (2)          #f 0        LIST   )
  65. ("member"                                (2)          #f 0        LIST   )
  66. ("assq"                                  (2)          #f 0        #f     )
  67. ("assv"                                  (2)          #f 0        #f     )
  68. ("assoc"                                 (2)          #f 0        #f     )
  69. ("symbol?"                               (1)          #f 0        BOOLEAN)
  70. ("symbol->string"                        (1)          #f 0        STRING )
  71. ("string->symbol"                        (1)          #f 0        SYMBOL )
  72. ("number?"                               (1)          #f 0        BOOLEAN)
  73. ("complex?"                              (1)          #f 0        BOOLEAN)
  74. ("real?"                                 (1)          #f 0        BOOLEAN)
  75. ("rational?"                             (1)          #f 0        BOOLEAN)
  76. ("integer?"                              (1)          #f 0        BOOLEAN)
  77. ("exact?"                                (1)          #f 0        BOOLEAN)
  78. ("inexact?"                              (1)          #f 0        BOOLEAN)
  79. ("="                                     0            #f 0        BOOLEAN)
  80. ("<"                                     0            #f 0        BOOLEAN)
  81. (">"                                     0            #f 0        BOOLEAN)
  82. ("<="                                    0            #f 0        BOOLEAN)
  83. (">="                                    0            #f 0        BOOLEAN)
  84. ("zero?"                                 (1)          #f 0        BOOLEAN)
  85. ("positive?"                             (1)          #f 0        BOOLEAN)
  86. ("negative?"                             (1)          #f 0        BOOLEAN)
  87. ("odd?"                                  (1)          #f 0        BOOLEAN)
  88. ("even?"                                 (1)          #f 0        BOOLEAN)
  89. ("max"                                   1            #f 0        NUMBER )
  90. ("min"                                   1            #f 0        NUMBER )
  91. ("+"                                     0            #f 0        NUMBER )
  92. ("*"                                     0            #f 0        NUMBER )
  93. ("-"                                     1            #f 0        NUMBER )
  94. ("/"                                     1            #f 0        NUMBER )
  95. ("abs"                                   (1)          #f 0        NUMBER )
  96. ("quotient"                              1            #f 0        INTEGER)
  97. ("remainder"                             (2)          #f 0        INTEGER)
  98. ("modulo"                                (2)          #f 0        INTEGER)
  99. ("gcd"                                   1            #f 0        INTEGER)
  100. ("lcm"                                   1            #f 0        INTEGER)
  101. ("numerator"                             (1)          #f 0        INTEGER)
  102. ("denominator"                           (1)          #f 0        INTEGER)
  103. ("floor"                                 (1)          #f 0        INTEGER)
  104. ("ceiling"                               (1)          #f 0        INTEGER)
  105. ("truncate"                              (1)          #f 0        INTEGER)
  106. ("round"                                 (1)          #f 0        INTEGER)
  107. ("rationalize"                           (2)          #f 0        NUMBER )
  108. ("exp"                                   (1)          #f 0        NUMBER )
  109. ("log"                                   (1)          #f 0        NUMBER )
  110. ("sin"                                   (1)          #f 0        NUMBER )
  111. ("cos"                                   (1)          #f 0        NUMBER )
  112. ("tan"                                   (1)          #f 0        NUMBER )
  113. ("asin"                                  (1)          #f 0        NUMBER )
  114. ("acos"                                  (1)          #f 0        NUMBER )
  115. ("atan"                                  (1 2)        #f 0        NUMBER )
  116. ("sqrt"                                  (1)          #f 0        NUMBER )
  117. ("expt"                                  (2)          #f 0        NUMBER )
  118. ("make-rectangular"                      (2)          #f 0        NUMBER )
  119. ("make-polar"                            (2)          #f 0        NUMBER )
  120. ("real-part"                             (1)          #f 0        REAL   )
  121. ("imag-part"                             (1)          #f 0        REAL   )
  122. ("magnitude"                             (1)          #f 0        REAL   )
  123. ("angle"                                 (1)          #f 0        REAL   )
  124. ("exact->inexact"                        (1)          #f 0        NUMBER )
  125. ("inexact->exact"                        (1)          #f 0        NUMBER )
  126. ("number->string"                        (1 2)        #f 0        STRING )
  127. ("string->number"                        (1 2)        #f 0        NUMBER )
  128. ("char?"                                 (1)          #f 0        BOOLEAN)
  129. ("char=?"                                0            #f 0        BOOLEAN)
  130. ("char<?"                                0            #f 0        BOOLEAN)
  131. ("char>?"                                0            #f 0        BOOLEAN)
  132. ("char<=?"                               0            #f 0        BOOLEAN)
  133. ("char>=?"                               0            #f 0        BOOLEAN)
  134. ("char-ci=?"                             0            #f 0        BOOLEAN)
  135. ("char-ci<?"                             0            #f 0        BOOLEAN)
  136. ("char-ci>?"                             0            #f 0        BOOLEAN)
  137. ("char-ci<=?"                            0            #f 0        BOOLEAN)
  138. ("char-ci>=?"                            0            #f 0        BOOLEAN)
  139. ("char-alphabetic?"                      (1)          #f 0        BOOLEAN)
  140. ("char-numeric?"                         (1)          #f 0        BOOLEAN)
  141. ("char-whitespace?"                      (1)          #f 0        BOOLEAN)
  142. ("char-upper-case?"                      (1)          #f 0        BOOLEAN)
  143. ("char-lower-case?"                      (1)          #f 0        BOOLEAN)
  144. ("char->integer"                         (1)          #f 0        INTEGER)
  145. ("integer->char"                         (1)          #f 0        CHAR   )
  146. ("char-upcase"                           (1)          #f 0        CHAR   )
  147. ("char-downcase"                         (1)          #f 0        CHAR   )
  148. ("string?"                               (1)          #f 0        BOOLEAN)
  149. ("make-string"                           (1 2)        #f 0        STRING )
  150. ("string"                                0            #f 0        STRING )
  151. ("string-length"                         (1)          #f 0        INTEGER)
  152. ("string-ref"                            (2)          #f 0        CHAR   )
  153. ("string-set!"                           (3)          #t 0        STRING )
  154. ("string=?"                              0            #f 0        BOOLEAN)
  155. ("string<?"                              0            #f 0        BOOLEAN)
  156. ("string>?"                              0            #f 0        BOOLEAN)
  157. ("string<=?"                             0            #f 0        BOOLEAN)
  158. ("string>=?"                             0            #f 0        BOOLEAN)
  159. ("string-ci=?"                           0            #f 0        BOOLEAN)
  160. ("string-ci<?"                           0            #f 0        BOOLEAN)
  161. ("string-ci>?"                           0            #f 0        BOOLEAN)
  162. ("string-ci<=?"                          0            #f 0        BOOLEAN)
  163. ("string-ci>=?"                          0            #f 0        BOOLEAN)
  164. ("substring"                             (3)          #f 0        STRING )
  165. ("string-append"                         0            #f 0        STRING )
  166. ("vector?"                               (1)          #f 0        BOOLEAN)
  167. ("make-vector"                           (1 2)        #f (1)      VECTOR )
  168. ("vector"                                0            #f ()       VECTOR )
  169. ("vector-length"                         (1)          #f 0        INTEGER)
  170. ("vector-ref"                            (2)          #f 0        (#f)   )
  171. ("vector-set!"                           (3)          #t (1 2)    VECTOR )
  172. ("procedure?"                            (1)          #f 0        BOOLEAN)
  173. ("apply"                                 2            #t 0        (#f)   )
  174. ("map"                                   2            #t 0        LIST   )
  175. ("for-each"                              2            #t 0        #f     )
  176. ("call-with-current-continuation"        (1)          #t 0        (#f)   )
  177. ("call-with-input-file"                  (2)          #t 0        (#f)   )
  178. ("call-with-output-file"                 (2)          #t 0        (#f)   )
  179. ("input-port?"                           (1)          #f 0        BOOLEAN)
  180. ("output-port?"                          (1)          #f 0        BOOLEAN)
  181. ("current-input-port"                    (0)          #f 0        PORT   )
  182. ("current-output-port"                   (0)          #f 0        PORT   )
  183. ("open-input-file"                       (1)          #t 0        PORT   )
  184. ("open-output-file"                      (1)          #t 0        PORT   )
  185. ("close-input-port"                      (1)          #t 0        #f     )
  186. ("close-output-port"                     (1)          #t 0        #f     )
  187. ("eof-object?"                           (1)          #f 0        BOOLEAN)
  188. ("read"                                  (0 1)        #t 0        #f     )
  189. ("read-char"                             (0 1)        #t 0        #f     )
  190. ("peek-char"                             (0 1)        #t 0        #f     )
  191. ("write"                                 (0 1)        #t 0        #f     )
  192. ("display"                               (0 1)        #t 0        #f     )
  193. ("newline"                               (0 1)        #t 0        #f     )
  194. ("write-char"                            (1 2)        #t 0        #f     )
  195.  
  196. ; for R4RS Scheme
  197.  
  198. ("list-tail"                             (2)          #f 0        (#f)   )
  199. ("string->list"                          (1)          #f 0        LIST   )
  200. ("list->string"                          (1)          #f 0        STRING )
  201. ("string-copy"                           (1)          #f 0        STRING )
  202. ("string-fill!"                          (2)          #t 0        STRING )
  203. ("vector->list"                          (1)          #f 0        LIST   )
  204. ("list->vector"                          (1)          #f 0        VECTOR )
  205. ("vector-fill!"                          (2)          #t 0        VECTOR )
  206. ("force"                                 (1)          #t 0        #f     )
  207. ("with-input-from-file"                  (2)          #t 0        (#f)   )
  208. ("with-output-to-file"                   (2)          #t 0        (#f)   )
  209. ("char-ready?"                           (0 1)        #f 0        BOOLEAN)
  210. ("load"                                  (1)          #t 0        (#f)   )
  211. ("transcript-on"                         (1)          #t 0        #f     )
  212. ("transcript-off"                        (0)          #t 0        #f     )
  213.  
  214. ; for Multilisp
  215.  
  216. ("touch"                                 (1)          #t 0        #f     )
  217.  
  218. ; for system interface
  219.  
  220. ("##type"                                (1)          #f ()       INTEGER)
  221. ("##type-cast"                           (2)          #f ()       (#f)   )
  222. ("##subtype"                             (1)          #f ()       INTEGER)
  223. ("##subtype-set!"                        (2)          #t ()       #f     )
  224.  
  225. ("##not"                                 (1)          #f ()       BOOLEAN)
  226. ("##null?"                               (1)          #f ()       BOOLEAN)
  227. ("##unassigned?"                         (1)          #f ()       BOOLEAN)
  228. ("##unbound?"                            (1)          #f ()       BOOLEAN)
  229. ("##eq?"                                 (2)          #f ()       BOOLEAN)
  230.  
  231. ("##fixnum?"                             (1)          #f ()       BOOLEAN)
  232. ("##special?"                            (1)          #f ()       BOOLEAN)
  233. ("##pair?"                               (1)          #f ()       BOOLEAN)
  234. ("##weak-pair?"                          (1)          #f ()       BOOLEAN)
  235. ("##subtyped?"                           (1)          #f ()       BOOLEAN)
  236. ("##procedure?"                          (1)          #f ()       BOOLEAN)
  237. ("##placeholder?"                        (1)          #f ()       BOOLEAN)
  238. ("##vector?"                             (1)          #f ()       BOOLEAN)
  239. ("##symbol?"                             (1)          #f ()       BOOLEAN)
  240. ("##ratnum?"                             (1)          #f ()       BOOLEAN)
  241. ("##cpxnum?"                             (1)          #f ()       BOOLEAN)
  242. ("##string?"                             (1)          #f ()       BOOLEAN)
  243. ("##bignum?"                             (1)          #f ()       BOOLEAN)
  244. ("##flonum?